// This file contains definitions for the
// x86 memory management unit (MMU).
// 这个文件包含了关于x86内存管理的常量    就只有两个问题都是小问题  87与25行

// Eflags register
// Interrupt Enable 中断允许位  控制IF位  IF位为0是屏蔽中断
// 该标志用于控制处理器对可屏蔽中断请求的响应。置1可以响应 可屏蔽中断，反之则禁止 可屏蔽中断（断好句就理解了）
#define FL_IF           0x00000200      

// Control Register flags 控制寄存器各位含义
#define CR0_PE          0x00000001      // Protection Enable PE=0,表示CPU处于实模式; PE=1表CPU处于保护模式
#define CR0_WP          0x00010000      // Write Protect 写保护未即WP位(486系列之后)，只要将这一位置0就可以禁用写保护，置1则可将其恢复
#define CR0_PG          0x80000000      // Paging 该位控制分页机制，PG=1，启动分页机制；PG=0,不使用分页机制

#define CR4_PSE         0x00000010      // Page size extension

// various segment selectors. 各种段选择子
#define SEG_KCODE 1  // kernel code
#define SEG_KDATA 2  // kernel data+stack
#define SEG_UCODE 3  // user code
#define SEG_UDATA 4  // user data+stack
#define SEG_TSS   5  // this process's task state  进程的任务状态

// cpu->gdt[NSEGS] holds the above segments.   保存上述段
#define NSEGS     6

#ifndef __ASSEMBLER__

// Segment Descriptor 段描述符结构体   用来定义段描述符的结构体   总的刚好是64位
struct segdesc {
  uint lim_15_0 : 16;  // Low bits of segment limit
  uint base_15_0 : 16; // Low bits of segment base address
  uint base_23_16 : 8; // Middle bits of segment base address
  uint type : 4;       // Segment type (see STS_ constants)    
  uint s : 1;          // 0 = system, 1 = application
  uint dpl : 2;        // Descriptor Privilege Level                    
  uint p : 1;          // Present
  uint lim_19_16 : 4;  // High bits of segment limit
  uint avl : 1;        // Unused (available for software use)
  uint rsv1 : 1;       // Reserved
  uint db : 1;         // 0 = 16-bit segment, 1 = 32-bit segment
  uint g : 1;          // Granularity: limit scaled by 4K when set
  uint base_31_24 : 8; // High bits of segment base address
};

// Normal segment普通段的宏定义  SEG中刚好有13个段参数对应segdesc结构体  将函数参数给到结构中，
#define SEG(type, base, lim, dpl) (struct segdesc)    \
{ ((lim) >> 12) & 0xffff, (uint)(base) & 0xffff,      \
  ((uint)(base) >> 16) & 0xff, type, 1, dpl, 1,       \
  (uint)(lim) >> 28, 0, 0, 1, 1, (uint)(base) >> 24 }
#define SEG16(type, base, lim, dpl) (struct segdesc)  \
{ (lim) & 0xffff, (uint)(base) & 0xffff,              \
  ((uint)(base) >> 16) & 0xff, type, 1, dpl, 1,       \
  (uint)(lim) >> 16, 0, 0, 1, 0, (uint)(base) >> 24 }
#endif

#define DPL_USER    0x3     // User DPL描述符特权级

// Application segment type bits    程序段类型
#define STA_X       0x8     // Executable segment 可执行段
#define STA_W       0x2     // Writeable (non-executable segments)
#define STA_R       0x2     // Readable (executable segments)

// System segment type bits      系统段类型
#define STS_T32A    0x9     // Available 32-bit TSS
#define STS_IG32    0xE     // 32-bit Interrupt Gate
#define STS_TG32    0xF     // 32-bit Trap Gate

// A virtual address 'la' has a three-part structure as follows:
//
// +--------10------+-------10-------+---------12----------+
// | Page Directory |   Page Table   | Offset within Page  |
// |      Index     |      Index     |                     |
// +----------------+----------------+---------------------+
//  \--- PDX(va) --/ \--- PTX(va) --/
//   最高10位是页目录索引指示页目录表中的第几页表描述符，
//   中间索引为页表索引指示第几个页描述符；

// page directory index 获得页目录的宏 右移22位就把最右边12位给清0了，然后利用and把中间10位给算出来
// 由于2的10次方。是1024.而pgdir是1024个。PDX出来就是16进制，实际把0给舍了
#define PDX(va)         (((uint)(va) >> PDXSHIFT) & 0x3FF)

// page table index 获得页表的宏  由于0x3FF只有10位，利用and把前10位舍了
#define PTX(va)         (((uint)(va) >> PTXSHIFT) & 0x3FF)

// construct virtual address（线性地址） from indexes and offset
// 通过两个索引和偏移量设置一个虚拟地址的宏                
// 根据页目录的页表，页表的页表项索引和偏移构建虚拟地址
#define PGADDR(d, t, o) ((uint)((d) << PDXSHIFT | (t) << PTXSHIFT | (o)))

// Page directory and page table constants.
#define NPDENTRIES      1024    // # directory entries per page directory   每个页表有1024个页目录
#define NPTENTRIES      1024    // # PTEs per page table  每个页目录有1024个PTEs
#define PGSIZE          4096    // bytes mapped by a page

#define PTXSHIFT        12      // offset of PTX in a linear address  线性地址中PTX的偏移量
#define PDXSHIFT        22      // offset of PDX in a linear address

#define PGROUNDUP(sz)  (((sz)+PGSIZE-1) & ~(PGSIZE-1))     // 为往上4k地址对齐，相当于可以把一个地址转换为比此地址高的4k地址
#define PGROUNDDOWN(a) (((a)) & ~(PGSIZE-1))      // 为往下4k地址对齐，相当于可以把一个地址转换为比此地址低的4k地址 

// 这里解释一下PGROUNDDOWN定义 PGSIZE-1是4095 刚好是 1111 1111 1111 取反就是 0000 0000 0000
// 由于4096是 0001 0000 0000 0000  十六进制就是0x1000 所以只要是低12位为0其高20位都是1的倍数

// Page table/directory entry flags.     页表标志位
#define PTE_P           0x001   // Present
#define PTE_W           0x002   // Writeable
#define PTE_U           0x004   // User
#define PTE_PS          0x080   // Page Size

// Address in page table or page directory entry  根据页表项的内容，提取地址和标识  

  // 将高20位取出来
#define PTE_ADDR(pte)   ((uint)(pte) & ~0xFFF)  

  // 将低12位取出来   
#define PTE_FLAGS(pte)  ((uint)(pte) &  0xFFF)     

#ifndef __ASSEMBLER__
typedef uint pte_t;

// Task state segment format         padding1 是什么，还有其他同类元素
struct taskstate {
  uint link;         // Old ts selector
  uint esp0;         // Stack pointers and segment selectors
  ushort ss0;        //   after an increase in privilege level
  ushort padding1;
  uint *esp1;
  ushort ss1;
  ushort padding2;
  uint *esp2;
  ushort ss2;
  ushort padding3;
  void *cr3;         // Page directory base
  uint *eip;         // Saved state from last task switch
  uint eflags;
  uint eax;          // More saved state (registers)
  uint ecx;
  uint edx;
  uint ebx;
  uint *esp;
  uint *ebp;
  uint esi;
  uint edi;
  ushort es;         // Even more saved state (segment selectors)
  ushort padding4;
  ushort cs;
  ushort padding5;
  ushort ss;
  ushort padding6;
  ushort ds;
  ushort padding7;
  ushort fs;
  ushort padding8;
  ushort gs;
  ushort padding9;
  ushort ldt;
  ushort padding10;
  ushort t;          // Trap on task switch
  ushort iomb;       // I/O map base address
};

// Gate descriptors for interrupts and traps 用于中断或陷入的门描述符结构体的定义 也是64位  
struct gatedesc {
  uint off_15_0 : 16;   // low 16 bits of offset in segment
  uint cs : 16;         // code segment selector
  uint args : 5;        // # args, 0 for interrupt/trap gates
  uint rsv1 : 3;        // reserved(should be zero I guess)
  uint type : 4;        // type(STS_{IG32,TG32})
  uint s : 1;           // must be 0 (system)
  uint dpl : 2;         // descriptor(meaning new) privilege level
  uint p : 1;           // Present
  uint off_31_16 : 16;  // high bits of offset in segment
};

// Set up a normal interrupt/trap gate descriptor.   建立一个正常的中断/陷阱门描述符
// - istrap: 1 for a trap (= exception) gate, 0 for an interrupt gate.
//   interrupt gate clears FL_IF, trap gate leaves FL_IF alone
// - sel: Code segment selector for interrupt/trap handler
// - off: Offset in code segment for interrupt/trap handler
// - dpl: Descriptor Privilege Level -
//        the privilege level required for software to invoke
//        this interrupt/trap gate explicitly using an int instruction. 
// gate是gatedesc段， define应该是将参数经过运算给到结构中
#define SETGATE(gate, istrap, sel, off, d)                \
{                                                         \
  (gate).off_15_0 = (uint)(off) & 0xffff;                \
  (gate).cs = (sel);                                      \
  (gate).args = 0;                                        \
  (gate).rsv1 = 0;                                        \
  (gate).type = (istrap) ? STS_TG32 : STS_IG32;           \
  (gate).s = 0;                                           \
  (gate).dpl = (d);                                       \
  (gate).p = 1;                                           \
  (gate).off_31_16 = (uint)(off) >> 16;                  \
}

#endif
